Python til IoT: En Omfattende Guide til MQTT-implementering

Den Forbundne Verden: Hvorfor IoT-protokoller er Vigtige

Vi lever i en tidsalder med hidtil uset forbundethed. Tingenes Internet (IoT) er ikke længere et futuristisk koncept; det er en global virkelighed, der stille og roligt væver et netværk af milliarder af smarte enheder, som overvåger vores miljø, automatiserer vores hjem, optimerer vores industrier og strømliner vores byer. Fra en smart termostat i et hjem i Seoul til en landbrugssensor på en mark i landdistrikterne i Kenya genererer disse enheder en kolossal mængde data. Men hvordan taler de alle sammen med hinanden og med skyen, især når de ofte er små, har lav effekt og opererer på upålidelige netværk? Svaret ligger i specialiserede kommunikationsprotokoller.

Selvom HTTP-protokollen driver det meste af det web, vi bruger dagligt, er den ofte for tung og strømkrævende for den begrænsede verden af IoT. Det er her, protokoller designet specifikt til maskine-til-maskine (M2M) kommunikation skinner igennem. Blandt dem er en trådt frem som en dominerende kraft: MQTT.

Denne omfattende guide er designet til udviklere, ingeniører og hobbyister verden over, der ønsker at udnytte kraften i MQTT ved hjælp af Python, et af de mest alsidige og populære programmeringssprog inden for IoT. Vi vil rejse fra de grundlæggende koncepter i MQTT til at bygge sikre, robuste og skalerbare IoT-applikationer.

Hvad er MQTT? En Protokol Bygget til Begrænsninger

MQTT står for Message Queuing Telemetry Transport. Den blev opfundet i 1999 af Dr. Andy Stanford-Clark fra IBM og Arlen Nipper fra Arcom (nu Cirrus Link) til overvågning af olierørledninger over upålidelige satellitnetværk. Dets oprindelseshistorie indkapsler perfekt dets formål: at være en let, pålidelig og effektiv meddelelsesprotokol for enheder, der opererer under betydelige begrænsninger.

Publish/Subscribe (Pub/Sub) Modellen Forklaret

I hjertet af MQTT ligger det elegante publish/subscribe arkitekturmønster. Dette er en fundamental afvigelse fra request/response-modellen i HTTP, som mange udviklere er bekendte med. I stedet for at en klient direkte anmoder om information fra en server, er kommunikationen afkoblet.

Forestil dig et globalt nyhedsbureau. Journalister (publishers) sender ikke deres historier direkte til hver enkelt læser. I stedet sender de deres historier til bureauets centrale hub (brokeren) og kategoriserer dem under specifikke emner som "Verdenspolitik" eller "Teknologi". Læsere (subscribers) behøver ikke at spørge journalisterne om opdateringer; de fortæller blot bureauet, hvilke emner de er interesserede i. Bureauet videresender derefter automatisk alle nye historier om disse emner til de interesserede læsere. Journalisterne og læserne behøver aldrig at kende til hinandens eksistens, placering eller status.

I MQTT afkobler denne model enheden, der sender data (publisher), fra enheden eller applikationen, der modtager dem (subscriber). Dette er utroligt kraftfuldt for IoT, fordi:

• Rumlig afkobling: Publisher og subscriber behøver ikke at kende hinandens IP-adresse eller placering.
• Tidsmæssig afkobling: De behøver ikke at køre på samme tid. En sensor kan publicere en måling, og en applikation kan modtage den timer senere, hvis systemet er designet til det.
• Synkroniseringsafkobling: Operationer på begge sider behøver ikke at blive standset for at vente på, at den anden fuldfører en meddelelsesudveksling.

Nøglekomponenter i MQTT-økosystemet

MQTT-arkitekturen er bygget op omkring nogle få kernekomponenter:

• Broker: Den centrale hub eller server. Det er posthuset i MQTT-verdenen. Brokeren er ansvarlig for at modtage alle beskeder fra publishers, filtrere dem efter emne (topic) og sende dem til de relevante subscribers. Populære brokere inkluderer open source-muligheder som Mosquitto og VerneMQ, samt administrerede cloud-tjenester som AWS IoT Core, Azure IoT Hub og Google Cloud IoT Core.
• Klient: Enhver enhed eller applikation, der forbinder til brokeren. En klient kan være en publisher, en subscriber eller begge dele. En IoT-sensor er en klient, og en serverapplikation, der behandler sensordataene, er også en klient.
• Topic: En UTF-8-streng, der fungerer som en adresse eller et mærkat for beskeder. Brokeren bruger topics til at route beskeder. Topics er hierarkiske og bruger skråstreger som separatorer, ligesom en filsti i et filsystem. For eksempel kunne et godt topic for en temperatursensor i en stue i en bygning i London være: DK/København/Bygning-A/Etage-1/Stue/Temperatur.
• Payload: Dette er det faktiske dataindhold i beskeden. MQTT er data-agnostisk, hvilket betyder, at payloaden kan være hvad som helst: en simpel streng, et heltal, JSON, XML eller endda krypterede binære data. JSON er et meget almindeligt valg på grund af sin fleksibilitet og læsbarhed.

Hvorfor MQTT Dominerer IoT-kommunikation

MQTT's designprincipper gør det usædvanligt velegnet til udfordringerne i IoT:

• Letvægt: MQTT-beskeder har en meget lille header (helt ned til 2 bytes), hvilket minimerer brugen af netværksbåndbredde. Dette er kritisk for enheder på dyre mobilabonnementer eller lavbåndbreddenetværk som LoRaWAN.
• Effektiv: Protokollens lave overhead oversættes direkte til lavere strømforbrug, hvilket gør det muligt for batteridrevne enheder at fungere i måneder eller endda år.
• Pålidelig: Den inkluderer funktioner til at sikre meddelelseslevering, selv over ustabile netværk med høj latenstid. Dette styres gennem Quality of Service-niveauer.
• Skalerbar: En enkelt broker kan håndtere forbindelser fra tusinder eller endda millioner af klienter samtidigt, hvilket gør den velegnet til store implementeringer.
• Tovejskommunikation: MQTT tillader kommunikation fra enhed-til-sky (telemetri) og sky-til-enhed (kommandoer), et afgørende krav for at kunne styre enheder fjernt.

Forståelse af Servicekvalitet (QoS)

MQTT tilbyder tre niveauer af Servicekvalitet (QoS) for at give udviklere mulighed for at vælge den rette balance mellem pålidelighed og overhead for deres specifikke anvendelsestilfælde.

• QoS 0 (Højst én gang): Dette er et "send og glem"-niveau. Beskeden sendes én gang uden bekræftelse på modtagelse fra brokeren eller den endelige subscriber. Det er den hurtigste metode, men giver ingen garanti for levering. Anvendelsestilfælde: Ikke-kritiske, højfrekvente sensordata, som f.eks. en omgivelsestemperatur, der sendes hvert 10. sekund. At miste en enkelt måling er ikke et problem.
• QoS 1 (Mindst én gang): Dette niveau garanterer, at beskeden vil blive leveret mindst én gang. Afsenderen gemmer beskeden, indtil den modtager en kvittering (en PUBACK-pakke) fra modtageren. Hvis der ikke modtages en kvittering, sendes beskeden igen. Dette kan undertiden resultere i duplikerede beskeder, hvis kvitteringen går tabt. Anvendelsestilfælde: En kommando til at tænde en smart pære. Du skal være sikker på, at kommandoen modtages, og at modtage den to gange forårsager ingen skade.
• QoS 2 (Præcis én gang): Dette er det mest pålidelige, men også det langsomste niveau. Det bruger et fire-trins håndtryk for at sikre, at beskeden leveres præcis én gang, uden duplikater. Anvendelsestilfælde: Kritiske operationer, hvor duplikater kunne være katastrofale, såsom en finansiel transaktion, en kommando til at udlevere en præcis mængde medicin, eller styring af en robotarm på en fabrik.

Opsætning af Dit Python MQTT-miljø

Lad os nu blive praktiske. For at begynde at bygge MQTT-applikationer med Python, har du brug for to ting: et Python-bibliotek til MQTT-klienten og en MQTT-broker at kommunikere med.

Valg af et Python MQTT-bibliotek: Paho-MQTT

Det mest udbredte og modne MQTT-bibliotek til Python er Paho-MQTT fra Eclipse Foundation. Det er et robust, funktionsrigt bibliotek, der giver en klientklasse til at forbinde til en broker og publicere eller abonnere på emner. Installationen er ligetil ved hjælp af pip, Pythons pakkehåndtering.

Åbn din terminal eller kommandoprompt og kør:

pip install paho-mqtt

Denne ene kommando installerer alt, hvad du behøver for at begynde at skrive MQTT-klienter i Python.

Opsætning af en MQTT Broker

Du har flere muligheder for en broker, fra at køre en på din lokale maskine til udvikling til at bruge en kraftfuld cloud-tjeneste til produktion.

• Lokal Broker (til udvikling og læring): Det mest populære valg for en lokal broker er Mosquitto, et andet Eclipse-projekt. Det er let, open source og nemt at installere.
  • På Debian-baseret Linux (som Ubuntu, Raspberry Pi OS): sudo apt-get update && sudo apt-get install mosquitto mosquitto-clients
  • På macOS (med Homebrew): brew install mosquitto
  • På Windows: Download den native installationsfil fra Mosquitto's hjemmeside.
  Når den er installeret, starter brokeren normalt automatisk som en service. Du kan bruge den ved at pege dine klienter mod din lokale IP-adresse (127.0.0.1 eller localhost).
• Offentlig/Cloud Broker (til hurtig test): Til indledende eksperimenter uden at installere noget, kan du bruge en gratis, offentlig broker. To populære er test.mosquitto.org og broker.hivemq.com. Vigtigt: Disse er offentlige og ukrypterede. Send ingen følsomme eller private data til dem. De er kun til lærings- og testformål.

Praktisk Anvendelse: Publicering og Abonnement med Python

Lad os skrive vores første Python MQTT-applikation. Vi vil oprette to separate scripts: en publisher, der sender beskeder, og en subscriber, der modtager dem. I dette eksempel antager vi, at du kører en lokal Mosquitto-broker.

Oprettelse af en Simpel MQTT Publisher (publisher.py)

Dette script vil forbinde til brokeren og publicere beskeden "Hello, MQTT!" til emnet `python/mqtt/test` hvert andet sekund.

Opret en fil ved navn `publisher.py` og tilføj følgende kode:

import paho.mqtt.client as mqtt

import time

# --- Konfiguration ---

BROKER_ADDRESS = "localhost" # Brug 'test.mosquitto.org' for en offentlig broker

PORT = 1883

TOPIC = "python/mqtt/test"

# --- Callback for forbindelse ---

def on_connect(client, userdata, flags, rc):

if rc == 0:

print("Forbundet til MQTT Broker!")

else:

print(f"Kunne ikke forbinde, returkode {rc}")

# --- Hovedscript ---

# 1. Opret en klientinstans

client = mqtt.Client("PublisherClient")

# 2. Tildel on_connect callback

client.on_connect = on_connect

# 3. Forbind til brokeren

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. Start en baggrundstråd for netværksløkken

client.loop_start()

try:

count = 0

while True:

count += 1

message = f"Hello, MQTT! Besked #{count}"

# 5. Publicer en besked

result = client.publish(TOPIC, message)

# Tjek om publicering lykkedes

status = result[0]

if status == 0:

print(f"Sendte `{message}` til topic `{TOPIC}`")

else:

print(f"Kunne ikke sende besked til topic {TOPIC}")

time.sleep(2)

except KeyboardInterrupt:

print("Publicering stoppet.")

finally:

# 6. Stop netværksløkken og afbryd forbindelsen

client.loop_stop()

client.disconnect()

print("Forbindelse til brokeren afbrudt.")

Oprettelse af en Simpel MQTT Subscriber (subscriber.py)

Dette script vil forbinde til den samme broker, abonnere på `python/mqtt/test`-emnet og printe alle beskeder, det modtager.

Opret en anden fil ved navn `subscriber.py`:

import paho.mqtt.client as mqtt

# --- Konfiguration ---

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "python/mqtt/test"

# --- Callback-funktioner ---

def on_connect(client, userdata, flags, rc):

if rc == 0:

print("Forbundet til MQTT Broker!")

# Abonner på emnet ved vellykket forbindelse

client.subscribe(TOPIC)

else:

print(f"Kunne ikke forbinde, returkode {rc}")

def on_message(client, userdata, msg):

# Afkod beskedens payload fra bytes til streng

payload = msg.payload.decode()

print(f"Modtog besked: `{payload}` på topic `{msg.topic}`")

# --- Hovedscript ---

# 1. Opret en klientinstans

client = mqtt.Client("SubscriberClient")

# 2. Tildel callbacks

client.on_connect = on_connect

client.on_message = on_message

# 3. Forbind til brokeren

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. Start netværksløkken (blokerende kald)

# Denne funktion håndterer genforbindelse og behandling af beskeder automatisk.

print("Subscriber lytter...")

client.loop_forever()

Kørsel af Eksemplet

1. Åbn to separate terminalvinduer.
2. I det første terminalvindue, kør subscriber-scriptet: python subscriber.py
3. Du skulle se beskeden "Subscriber lytter...". Den venter nu på beskeder.
4. I det andet terminalvindue, kør publisher-scriptet: python publisher.py
5. Du vil se publisheren sende beskeder hvert andet sekund. Samtidig vil disse beskeder dukke op i subscriberens terminalvindue.

Tillykke! Du har netop oprettet et komplet, fungerende MQTT-kommunikationssystem ved hjælp af Python.

Ud over det Grundlæggende: Avancerede Paho-MQTT Funktioner

Virkelige IoT-systemer kræver mere robusthed end vores simple eksempel. Lad os udforske nogle avancerede MQTT-funktioner, der er essentielle for at bygge produktionsklare applikationer.

Sidste Vilje og Testamente (LWT)

Hvad sker der, hvis en kritisk enhed, som et sikkerhedskamera eller en hjertemonitor, uventet afbryder forbindelsen på grund af strømsvigt eller netværkstab? LWT-funktionen er MQTT's løsning. Når en klient opretter forbindelse, kan den registrere en "sidste vilje"-besked hos brokeren. Hvis klienten afbryder forbindelsen unormalt (uden at sende en DISCONNECT-pakke), vil brokeren automatisk publicere denne sidste vilje-besked på dens vegne til et specificeret emne.

Dette er uvurderligt for overvågning af enhedsstatus. Du kan have en enhed, der publicerer en `enheder/enhed-123/status`-besked med payloaden `"online"`, når den forbinder, og registrere en LWT-besked med det samme emne, men med payloaden `"offline"`. Enhver overvågningstjeneste, der abonnerer på dette emne, vil øjeblikkeligt kende enhedens status.

For at implementere LWT i Paho-MQTT, indstiller du det, før du forbinder:

client.will_set('devices/device-123/status', payload='offline', qos=1, retain=True)

client.connect(BROKER_ADDRESS, PORT, 60)

Fastholdte Beskeder

Normalt, hvis en subscriber forbinder til et emne, vil den kun modtage beskeder, der publiceres efter den har abonneret. Men hvad nu hvis du har brug for den seneste værdi med det samme? Det er her, fastholdte beskeder kommer ind i billedet. Når en besked publiceres med `retain`-flaget sat til `True`, gemmer brokeren den besked for det specifikke emne. Hver gang en ny klient abonnerer på det emne, vil den øjeblikkeligt modtage den senest fastholdte besked.

Dette er perfekt til statusinformation. En enhed kan publicere sin tilstand (f.eks. `{"state": "ON"}`) med `retain=True`. Enhver applikation, der starter op og abonnerer, vil straks kende enhedens aktuelle tilstand uden at skulle vente på den næste opdatering.

I Paho-MQTT tilføjer du simpelthen `retain`-flaget til dit publish-kald:

client.publish(TOPIC, payload, qos=1, retain=True)

Vedvarende Sessioner og Rene Sessioner

`clean_session`-flaget i klientens forbindelsesanmodning styrer, hvordan brokeren håndterer klientens session.

• Ren Session (clean_session=True, standard): Når klienten afbryder forbindelsen, kasserer brokeren al information om den, inklusiv dens abonnementer og eventuelle køede QoS 1 eller 2 beskeder. Når den genopretter forbindelsen, er det som en helt ny klient.
• Vedvarende Session (clean_session=False): Når en klient med et unikt Klient ID forbinder på denne måde, opretholder brokeren dens session, efter den har afbrudt forbindelsen. Dette inkluderer dens abonnementer og eventuelle QoS 1 eller 2 beskeder, der blev publiceret, mens den var offline. Når klienten genopretter forbindelsen, sender brokeren alle de mistede beskeder. Dette er afgørende for enheder på upålidelige netværk, der ikke har råd til at miste kritiske kommandoer.

For at etablere en vedvarende session skal du angive et stabilt, unikt Klient ID og sætte `clean_session=False`, når du opretter klientinstansen:

client = mqtt.Client(client_id="my-persistent-device-001", clean_session=False)

Sikkerhed er Ikke en Mulighed: Sikring af MQTT med Python

I enhver virkelig applikation er sikkerhed altafgørende. En usikret MQTT-broker er en åben invitation for ondsindede aktører til at aflytte dine data, sende falske kommandoer til dine enheder eller iværksætte denial-of-service-angreb. Sikring af MQTT involverer tre centrale søjler: Autentificering, Kryptering og Autorisation.

Autentificering: Hvem er du?

Autentificering verificerer identiteten af den klient, der forbinder til brokeren. Den simpleste metode er at bruge et brugernavn og en adgangskode. Du kan konfigurere din Mosquitto-broker til at kræve legitimationsoplysninger og derefter angive dem i din Python-klient.

I din Python-klient, brug `username_pw_set()`-metoden:

client.username_pw_set(username="myuser", password="mypassword")

client.connect(BROKER_ADDRESS, PORT, 60)

Kryptering: Beskyttelse af Data under Overførsel med TLS/SSL

Brugernavn og adgangskode er til ringe nytte, hvis de sendes i klartekst over netværket. Kryptering sikrer, at al kommunikation mellem klienten og brokeren er forvrænget og ulæselig for enhver, der lytter på netværket. Dette opnås ved hjælp af Transport Layer Security (TLS), den samme teknologi, der sikrer websteder (HTTPS).

For at bruge TLS med MQTT (ofte kaldet MQTTS), skal du konfigurere din broker til at understøtte det (normalt på port 8883) og levere de nødvendige certifikater til din klient. Dette involverer typisk et Certificate Authority (CA) certifikat for at verificere brokerens identitet.

I Paho-MQTT bruger du `tls_set()`-metoden:

client.tls_set(ca_certs="path/to/ca.crt")

client.connect(BROKER_ADDRESS, 8883, 60)

Autorisation: Hvad har du Lov til at Gøre?

Når en klient er autentificeret, bestemmer autorisation, hvad den har tilladelse til at gøre. For eksempel bør en temperatursensor kun have lov til at publicere til sit eget emne (f.eks. `sensorer/temp-A/data`), men ikke til et emne, der bruges til at styre en fabriks maskineri (f.eks. `fabrik/etage-1/robotarm/kommando`). Dette håndteres typisk på brokeren ved hjælp af adgangskontrollister (ACLs). Du konfigurerer brokeren med regler, der definerer, hvilke brugere der kan `læse` (abonnere) eller `skrive` (publicere) til specifikke emnemønstre.

Samling af det Hele: Et Simpelt Smart Miljøovervågningsprojekt

Lad os bygge et lidt mere realistisk projekt for at cementere disse koncepter. Vi vil simulere en sensorenhed, der publicerer miljødata som et JSON-objekt, og en overvågningsapplikation, der abonnerer på disse data og viser dem.

Projektoversigt

• Sensoren (Publisher): Et Python-script, der simulerer en sensor, der aflæser temperatur og fugtighed. Det vil pakke disse data i en JSON-payload og publicere den til emnet smart_env/device01/telemetry hvert 5. sekund.
• Monitoren (Subscriber): Et Python-script, der abonnerer på `smart_env/device01/telemetry`, modtager JSON-data, parser dem og udskriver en brugervenlig statusopdatering.

Sensorkoden (sensor_publisher.py)

import paho.mqtt.client as mqtt

import time

import json

import random

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "smart_env/device01/telemetry"

client = mqtt.Client("SensorDevice01")

client.connect(BROKER_ADDRESS, PORT, 60)

client.loop_start()

print("Sensor publisher startet...")

try:

while True:

# Simuler sensoraflæsninger

temperature = round(random.uniform(20.0, 30.0), 2)

humidity = round(random.uniform(40.0, 60.0), 2)

# Opret en JSON-payload

payload = {

"timestamp": time.time(),

"temperature": temperature,

"humidity": humidity

}

payload_str = json.dumps(payload)

# Publicer beskeden med QoS 1

result = client.publish(TOPIC, payload_str, qos=1)

result.wait_for_publish() # Bloker indtil publicering er bekræftet

print(f"Publiceret: {payload_str}")

time.sleep(5)

except KeyboardInterrupt:

print("Stopper sensor publisher...")

finally:

client.loop_stop()

client.disconnect()

Overvågningsdashboard Koden (monitor_subscriber.py)

import paho.mqtt.client as mqtt

import json

import datetime

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "smart_env/device01/telemetry"

def on_connect(client, userdata, flags, rc):

print(f"Forbundet med resultatkode {rc}")

client.subscribe(TOPIC)

def on_message(client, userdata, msg):

print("--- Ny Besked Modtaget ---")

try:

# Afkod payload-strengen og parse den som JSON

payload = json.loads(msg.payload.decode())

timestamp = datetime.datetime.fromtimestamp(payload.get('timestamp'))

temperature = payload.get('temperature')

humidity = payload.get('humidity')

print(f"Enhed: {msg.topic}")

print(f"Tid: {timestamp.strftime('%Y-%m-%d %H:%M:%S')}")

print(f"Temperatur: {temperature}°C")

print(f"Fugtighed: {humidity}%")

except json.JSONDecodeError:

print("Fejl ved afkodning af JSON payload.")

except Exception as e:

print(f"Der opstod en fejl: {e}")

client = mqtt.Client("MonitoringDashboard")

client.on_connect = on_connect

client.on_message = on_message

client.connect(BROKER_ADDRESS, PORT, 60)

print("Overvågningsdashboard kører...")

client.loop_forever()

Fra Prototype til Produktion: Bedste Praksis for MQTT

At flytte dit projekt fra et simpelt script til et robust, skalerbart produktionssystem kræver omhyggelig planlægning. Her er nogle essentielle bedste praksisser:

• Design et Tydeligt Topic-hierarki: Planlæg din topic-struktur omhyggeligt fra starten. Et godt hierarki er beskrivende, skalerbart og tillader fleksible abonnementer ved hjælp af wildcards. Et almindeligt mønster er ////.
• Håndter Netværksafbrydelser Elegant: Netværk er upålidelige. Din klientkode bør implementere robust genforbindelseslogik. `on_disconnect`-callback'en i Paho-MQTT er det perfekte sted at starte dette, ved at implementere en strategi som eksponentiel backoff for at undgå at oversvømme netværket med genforbindelsesforsøg.
• Brug Strukturerede Data-payloads: Brug altid et struktureret dataformat som JSON eller Protocol Buffers til dine besked-payloads. Dette gør dine data selvbeskrivende, versionerbare og lette at parse for forskellige applikationer (skrevet i ethvert sprog).
• Sikr Alt som Standard: Implementer ikke et IoT-system uden sikkerhed. Brug som minimum brugernavn/adgangskode-autentificering og TLS-kryptering. For højere sikkerhedsbehov, udforsk klientcertifikat-baseret autentificering.
• Overvåg Din Broker: I et produktionsmiljø er din MQTT-broker en kritisk del af infrastrukturen. Brug overvågningsværktøjer til at spore dens sundhed, herunder CPU/hukommelsesforbrug, antal tilsluttede klienter, meddelelsesrater og tabte beskeder. Mange brokere afslører et specielt `$SYS` topic-hierarki, der giver denne statusinformation.

Konklusion: Din Rejse med Python og MQTT

Vi har rejst fra det fundamentale "hvorfor" om MQTT til det praktiske "hvordan" man implementerer det med Python. Du har lært om kraften i publish/subscribe-modellen, vigtigheden af QoS, og den kritiske rolle, som sikkerhed spiller. Du har set, hvordan Paho-MQTT-biblioteket gør det bemærkelsesværdigt enkelt at bygge sofistikerede klienter, der kan publicere sensordata og abonnere på kommandoer.

MQTT er mere end blot en protokol; det er en grundlæggende teknologi for Tingenes Internet. Dens lette natur og robuste funktioner har gjort den til det foretrukne valg for millioner af enheder over hele kloden, fra smarte byer til forbundet landbrug og industriel automation.

Rejsen slutter ikke her. Næste skridt er at tage disse koncepter og anvende dem på rigtig hardware. Eksperimenter med en Raspberry Pi, en ESP32 eller andre mikrocontrollere. Tilslut fysiske sensorer, integrer med cloud IoT-platforme, og byg applikationer, der interagerer med den fysiske verden. Med Python og MQTT har du et kraftfuldt værktøjssæt til at bygge den næste generation af forbundne løsninger.